{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table style=\"border: none\" align=\"center\">\n",
    "   <tr style=\"border: none\">\n",
    "      <th style=\"border: none\"><font face=\"verdana\" size=\"4\" color=\"black\"><b>  Demonstrate adversarial training using ART  </b></font></font></th>\n",
    "   </tr> \n",
    "</table>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook we demonstrate adversarial training using ART on the MNIST dataset.\n",
    "\n",
    "\n",
    "## Contents\n",
    "\n",
    "1.\t[Load prereqs and data](#prereqs)\n",
    "2.  [Train and evaluate a baseline classifier](#classifier)\n",
    "3.  [Adversarially train a robust classifier](#adv_training)\n",
    "4.\t[Evaluate the robust classifier](#evaluation)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"prereqs\"></a>\n",
    "## 1. Load prereqs and data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "from keras.models import load_model\n",
    "\n",
    "import tensorflow as tf\n",
    "tf.compat.v1.disable_eager_execution()\n",
    "\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D\n",
    "from tensorflow.keras.losses import categorical_crossentropy\n",
    "from tensorflow.keras.optimizers.legacy import Adam\n",
    "\n",
    "from art import config\n",
    "from art.utils import load_dataset, get_file\n",
    "from art.estimators.classification import KerasClassifier\n",
    "from art.attacks.evasion import FastGradientMethod, BasicIterativeMethod, ProjectedGradientDescent\n",
    "from art.defences.trainer import AdversarialTrainer\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import h5py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "(x_train, y_train), (x_test, y_test), min_, max_ = load_dataset('mnist')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"classifier\"></a>\n",
    "## 2. Train and evaluate a baseline classifier"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the classifier model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-09-19 14:31:01.288987: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:375] MLIR V1 optimization pass is not enabled\n",
      "2023-09-19 14:31:01.295803: W tensorflow/c/c_api.cc:304] Operation '{name:'dense_1/kernel/Assign' id:91 op device:{requested: '', assigned: ''} def:{{{node dense_1/kernel/Assign}} = AssignVariableOp[_has_manual_control_dependencies=true, dtype=DT_FLOAT, validate_shape=false](dense_1/kernel, dense_1/kernel/Initializer/stateless_random_uniform)}}' was changed by setting attribute after it was run by a session. This mutation will have no effect, and will trigger an error in the future. Either don't modify nodes after running them or create a new session.\n",
      "2023-09-19 14:31:01.359120: W tensorflow/c/c_api.cc:304] Operation '{name:'conv2d_1/kernel/m/Assign' id:252 op device:{requested: '', assigned: ''} def:{{{node conv2d_1/kernel/m/Assign}} = AssignVariableOp[_has_manual_control_dependencies=true, dtype=DT_FLOAT, validate_shape=false](conv2d_1/kernel/m, conv2d_1/kernel/m/Initializer/zeros)}}' was changed by setting attribute after it was run by a session. This mutation will have no effect, and will trigger an error in the future. Either don't modify nodes after running them or create a new session.\n"
     ]
    }
   ],
   "source": [
    "path = get_file('mnist_cnn_original.h5', extract=False, path=config.ART_DATA_PATH,\n",
    "                url='https://www.dropbox.com/s/p2nyzne9chcerid/mnist_cnn_original.h5?dl=1')\n",
    "classifier_model = load_model(path)\n",
    "classifier = KerasClassifier(clip_values=(min_, max_), model=classifier_model, use_logits=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# classifier_model = Sequential()\n",
    "# classifier_model.add(Conv2D(filters=32, kernel_size=(3, 3), strides=1, activation=\"relu\", input_shape=(28, 28, 1)))\n",
    "# classifier_model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "# classifier_model.add(Conv2D(filters=64, kernel_size=(3, 3), strides=1, activation=\"relu\", input_shape=(23, 23, 4)))\n",
    "# classifier_model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "# classifier_model.add(Flatten())\n",
    "# classifier_model.add(Dense(128, activation=\"relu\"))\n",
    "# classifier_model.add(Dense(10, activation=\"softmax\"))\n",
    "\n",
    "# classifier_model.compile(loss=categorical_crossentropy, optimizer=Adam(learning_rate=1e-4), metrics=[\"accuracy\"])\n",
    "\n",
    "# classifier = KerasClassifier(clip_values=(min_, max_), model=classifier_model, use_logits=False)\n",
    "\n",
    "# classifier.fit(x_train, y_train, nb_epochs=10, batch_size=128)\n",
    "\n",
    "# classifier.model.save(\"./mnist_cnn_original.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv2d (Conv2D)             (None, 26, 26, 32)        320       \n",
      "                                                                 \n",
      " max_pooling2d (MaxPooling2  (None, 13, 13, 32)        0         \n",
      " D)                                                              \n",
      "                                                                 \n",
      " conv2d_1 (Conv2D)           (None, 11, 11, 64)        18496     \n",
      "                                                                 \n",
      " max_pooling2d_1 (MaxPoolin  (None, 5, 5, 64)          0         \n",
      " g2D)                                                            \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 1600)              0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 128)               204928    \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 10)                1290      \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 225034 (879.04 KB)\n",
      "Trainable params: 225034 (879.04 KB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "classifier_model.summary()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate the classifier performance on the first 100 original test samples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-09-19 14:31:01.457593: W tensorflow/c/c_api.cc:304] Operation '{name:'dense_1/Softmax' id:102 op device:{requested: '', assigned: ''} def:{{{node dense_1/Softmax}} = Softmax[T=DT_FLOAT, _has_manual_control_dependencies=true](dense_1/BiasAdd)}}' was changed by setting attribute after it was run by a session. This mutation will have no effect, and will trigger an error in the future. Either don't modify nodes after running them or create a new session.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original test data:\n",
      "Correctly classified: 9842\n",
      "Incorrectly classified: 158\n"
     ]
    }
   ],
   "source": [
    "x_test_pred = np.argmax(classifier.predict(x_test), axis=1)\n",
    "nb_correct_pred = np.sum(x_test_pred == np.argmax(y_test, axis=1))\n",
    "\n",
    "print(\"Original test data:\")\n",
    "print(\"Correctly classified: {}\".format(nb_correct_pred))\n",
    "print(\"Incorrectly classified: {}\".format(len(x_test)-nb_correct_pred))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate some adversarial samples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "attacker = FastGradientMethod(classifier, eps=0.5)\n",
    "x_test_adv = attacker.generate(x_test, y_test)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And evaluate performance on those:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adversarial test data:\n",
      "Correctly classified: 31\n",
      "Incorrectly classified: 9969\n"
     ]
    }
   ],
   "source": [
    "x_test_adv_pred = np.argmax(classifier.predict(x_test_adv), axis=1)\n",
    "nb_correct_adv_pred = np.sum(x_test_adv_pred == np.argmax(y_test, axis=1))\n",
    "\n",
    "print(\"Adversarial test data:\")\n",
    "print(\"Correctly classified: {}\".format(nb_correct_adv_pred))\n",
    "print(\"Incorrectly classified: {}\".format(len(x_test_adv)-nb_correct_adv_pred))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"adv_training\"></a>\n",
    "## 3. Adversarially train a robust classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-09-19 14:31:06.507905: W tensorflow/c/c_api.cc:304] Operation '{name:'dense_3/bias/Assign' id:573 op device:{requested: '', assigned: ''} def:{{{node dense_3/bias/Assign}} = AssignVariableOp[_has_manual_control_dependencies=true, dtype=DT_FLOAT, validate_shape=false](dense_3/bias, dense_3/bias/Initializer/zeros)}}' was changed by setting attribute after it was run by a session. This mutation will have no effect, and will trigger an error in the future. Either don't modify nodes after running them or create a new session.\n",
      "2023-09-19 14:31:06.591307: W tensorflow/c/c_api.cc:304] Operation '{name:'conv2d_2/kernel/m/Assign' id:717 op device:{requested: '', assigned: ''} def:{{{node conv2d_2/kernel/m/Assign}} = AssignVariableOp[_has_manual_control_dependencies=true, dtype=DT_FLOAT, validate_shape=false](conv2d_2/kernel/m, conv2d_2/kernel/m/Initializer/zeros)}}' was changed by setting attribute after it was run by a session. This mutation will have no effect, and will trigger an error in the future. Either don't modify nodes after running them or create a new session.\n"
     ]
    }
   ],
   "source": [
    "path = get_file('mnist_cnn_robust.h5', extract=False, path=config.ART_DATA_PATH,\n",
    "                url='https://www.dropbox.com/s/yutsncaniiy5uy8/mnist_cnn_robust.h5?dl=1')\n",
    "robust_classifier_model = load_model(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# robust_classifier_model = Sequential()\n",
    "# robust_classifier_model.add(Conv2D(filters=32, kernel_size=(3, 3), strides=1, activation=\"relu\", input_shape=(28, 28, 1)))\n",
    "# robust_classifier_model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "# robust_classifier_model.add(Conv2D(filters=64, kernel_size=(3, 3), strides=1, activation=\"relu\", input_shape=(23, 23, 4)))\n",
    "# robust_classifier_model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "# robust_classifier_model.add(Flatten())\n",
    "# robust_classifier_model.add(Dense(1024, activation=\"relu\"))\n",
    "# robust_classifier_model.add(Dense(10, activation=\"softmax\"))\n",
    "\n",
    "# robust_classifier_model.compile(loss=categorical_crossentropy, optimizer=Adam(learning_rate=1e-4), metrics=[\"accuracy\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "robust_classifier = KerasClassifier(clip_values=(min_, max_), model=robust_classifier_model, use_logits=False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: the robust classifier has the same architecture as above, except the first dense layer has **1024** instead of **128** units. (This was recommend by Madry et al. (2017), *Towards Deep Learning Models Resistant to Adversarial Attacks*)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv2d_2 (Conv2D)           (None, 26, 26, 32)        320       \n",
      "                                                                 \n",
      " max_pooling2d_2 (MaxPoolin  (None, 13, 13, 32)        0         \n",
      " g2D)                                                            \n",
      "                                                                 \n",
      " conv2d_3 (Conv2D)           (None, 11, 11, 64)        18496     \n",
      "                                                                 \n",
      " max_pooling2d_3 (MaxPoolin  (None, 5, 5, 64)          0         \n",
      " g2D)                                                            \n",
      "                                                                 \n",
      " flatten_1 (Flatten)         (None, 1600)              0         \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 1024)              1639424   \n",
      "                                                                 \n",
      " dense_3 (Dense)             (None, 10)                10250     \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 1668490 (6.36 MB)\n",
      "Trainable params: 1668490 (6.36 MB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "robust_classifier_model.summary()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also as recommended by Madry et al., we use BIM/PGD attacks during adversarial training:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "attacks = BasicIterativeMethod(robust_classifier, eps=0.3, eps_step=0.01, max_iter=40)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perform adversarial training:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We had performed this before, starting with a randomly initialized model.\n",
    "# Adversarial training takes about 20 minutes on an NVIDIA A100.\n",
    "# The resulting model is the one loaded from mnist_cnn_robust.h5 above.\n",
    "\n",
    "# Here is the command we had used for the Adversarial Training\n",
    "\n",
    "# trainer = AdversarialTrainer(robust_classifier, attacks, ratio=1.0)\n",
    "# trainer.fit(x_train, y_train, nb_epochs=10, batch_size=128)\n",
    "\n",
    "# trainer.classifier.model.save(\"./mnist_cnn_robust.h5\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"evaluation\"></a>\n",
    "## 4. Evaluate the robust classifier"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate the robust classifier's performance on the original test data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-09-19 14:31:06.717139: W tensorflow/c/c_api.cc:304] Operation '{name:'dense_3/Softmax' id:579 op device:{requested: '', assigned: ''} def:{{{node dense_3/Softmax}} = Softmax[T=DT_FLOAT, _has_manual_control_dependencies=true](dense_3/BiasAdd)}}' was changed by setting attribute after it was run by a session. This mutation will have no effect, and will trigger an error in the future. Either don't modify nodes after running them or create a new session.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original test data:\n",
      "Correctly classified: 9736\n",
      "Incorrectly classified: 264\n"
     ]
    }
   ],
   "source": [
    "x_test_robust_pred = np.argmax(robust_classifier.predict(x_test), axis=1)\n",
    "nb_correct_robust_pred = np.sum(x_test_robust_pred == np.argmax(y_test, axis=1))\n",
    "\n",
    "print(\"Original test data:\")\n",
    "print(\"Correctly classified: {}\".format(nb_correct_robust_pred))\n",
    "print(\"Incorrectly classified: {}\".format(len(x_test)-nb_correct_robust_pred))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate the robust classifier's performance on the adversarial test data (**white-box** setting):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "attacker_robust = FastGradientMethod(robust_classifier, eps=0.5)\n",
    "x_test_adv_robust = attacker_robust.generate(x_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adversarial test data:\n",
      "Correctly classified: 1382\n",
      "Incorrectly classified: 8618\n"
     ]
    }
   ],
   "source": [
    "x_test_adv_robust_pred = np.argmax(robust_classifier.predict(x_test_adv_robust), axis=1)\n",
    "nb_correct_adv_robust_pred = np.sum(x_test_adv_robust_pred == np.argmax(y_test, axis=1))\n",
    "\n",
    "print(\"Adversarial test data:\")\n",
    "print(\"Correctly classified: {}\".format(nb_correct_adv_robust_pred))\n",
    "print(\"Incorrectly classified: {}\".format(len(x_test_adv_robust)-nb_correct_adv_robust_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "attacker_pgd = ProjectedGradientDescent(estimator=classifier, eps=0.5, eps_step=0.01, max_iter=200, verbose=False)\n",
    "attacker_robust_pgd = ProjectedGradientDescent(estimator=robust_classifier, eps=0.5, eps_step=0.01, max_iter=200, verbose=False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compare the performance of the original and the robust classifier over a range of `eps` values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "eps_range = [0.01, 0.02, 0.03, 0.04, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6]\n",
    "nb_correct_original = []\n",
    "nb_correct_robust = []\n",
    "\n",
    "nb_samples = 100\n",
    "\n",
    "for eps in eps_range:\n",
    "    attacker_pgd.set_params(**{'eps': eps})\n",
    "    attacker_robust_pgd.set_params(**{'eps': eps})\n",
    "    x_test_adv = attacker_pgd.generate(x_test[:nb_samples], y_test[:nb_samples])\n",
    "    x_test_adv_robust = attacker_robust_pgd.generate(x_test[:nb_samples], y_test[:nb_samples])\n",
    "    \n",
    "    x_test_adv_pred = np.argmax(classifier.predict(x_test_adv), axis=1)\n",
    "    nb_correct_original += [np.sum(x_test_adv_pred == np.argmax(y_test[:nb_samples], axis=1)) / nb_samples]\n",
    "    \n",
    "    x_test_adv_robust_pred = np.argmax(robust_classifier.predict(x_test_adv_robust), axis=1)\n",
    "    nb_correct_robust += [np.sum(x_test_adv_robust_pred == np.argmax(y_test[:nb_samples], axis=1)) / nb_samples]\n",
    "\n",
    "eps_range = [0] + eps_range\n",
    "nb_correct_original = [nb_correct_pred / 10000] + nb_correct_original\n",
    "nb_correct_robust = [nb_correct_robust_pred / 10000] + nb_correct_robust"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.plot(np.array(eps_range), np.array(nb_correct_original), 'b--', label='Original classifier')\n",
    "ax.plot(np.array(eps_range), np.array(nb_correct_robust), 'r--', label='Robust classifier')\n",
    "\n",
    "legend = ax.legend(loc='upper right', shadow=True, fontsize='large')\n",
    "\n",
    "plt.xlabel('Peturbation size (eps, L-Inf)')\n",
    "plt.ylabel('Classification Accuracy')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
